from django.shortcuts import render

from django.views import View
from apps.users.models import User
from django.http import JsonResponse
import re
import json
from django_redis import get_redis_connection  # 用于连接Redis
import logging

from django.contrib.auth import authenticate, login  # 用于验证用户名和密码

logger = logging.getLogger('django')  # 日志对象，用于记录调试信息
class UsernameCountView(View):
    """判断用户名是否重复注册"""

    def get(self, request, username):
        """
        :param request: 请求对象
        :param username: 用户名
        :return: JSON
        """
        count = User.objects.filter(username=username).count()
        return JsonResponse({'code': 0, 'errmsg': 'OK', 'count': count})

class MobileCountView(View):
    """判断手机号是否重复注册"""

    def get(self, request, mobile):
        """
        :param request: 请求对象
        :param mobile: 手机号
        :return: JSON
        """
        # #1. 接受用户名，对这个用户进行一下判断
        # if not re.match('[a-zA-Z0-9_-]{5,20}',username):
        #     return JsonResponse({'code':0,'errmsg':'用户名不满足需求'})
        count = User.objects.filter(mobile=mobile).count()
        return JsonResponse({'code': 0, 'errmsg': 'OK', 'count':count})

class RegisterView(View):
    """用户注册"""
    def post(self,request):
        """
        :param request: 请求对象
        :return: JSON注册结果
        """

        """
        # 1. 接收参数
        # 1.1 从请求体中提取JSON字符串
        # 1.2 从JSON字符串中提取参数
        # 2. 校验参数
        # 2.1 校验是否为空
        # 2.2 校验手机号
        # 2.3 校验密码
        # 2.4 校验确认密码
        # 2.5 校验短信验证码
        # 3. 注册用户
        # 4. 返回响应
        """
        #body_bytes代表的是请求体中的二进制数据
        #body_str代表的是请求体中的JSON字符串
        #body_dict代表的是请求体中的JSON字典
        body_bytes = request.body
        body_str = body_bytes.decode()
        body_dict = json.loads(body_str)
        # 1.2 从JSON字符串中提取参数
        username = body_dict.get('username')
        password = body_dict.get('password')
        password2 = body_dict.get('password2')
        mobile = body_dict.get('mobile')
        allow = body_dict.get('allow')
        sms_code = body_dict.get('sms_code')
        # 2. 校验参数
        # 2.1 校验是否为空
        # 判断参数是否齐全
        if not all([username,password,password2,mobile,allow]):
            return JsonResponse({'code':1,'errmsg':'参数不能为空'})
        # 判断用户名是否满足需求
        if not re.match('[a-zA-Z0-9_-]{5,20}',username):
            return JsonResponse({'code':1,'errmsg':'用户名不满足需求'})
        # 判断手机号是否满足需求
        if not re.match('^1[3-9]\d{9}$',mobile):
            return JsonResponse({'code':1,'errmsg':'手机号不满足需求'})
        # 判断密码是否满足需求
        if not re.match('^[a-zA-Z0-9]{8,20}$',password):
            return JsonResponse({'code':1,'errmsg':'密码不满足需求'})
        # 判断确认密码是否满足需求
        if password != password2:
            return JsonResponse({'code':1,'errmsg':'两次密码不一致'})
        # 判断短信验证码是否满足需求
        if not re.match('^\d{4}$',sms_code):
            return JsonResponse({'code':1,'errmsg':'短信验证码不满足需求'})
        
         # ========== 新增：验证短信验证码的有效性 ==========
        # 1. 连接Redis（库名要和存短信验证码时一致，比如SmsCodeView用的是'code'库）
        redis_conn = get_redis_connection('code')
        # 2. 从Redis中获取存储的短信验证码（键为 'sms_手机号'）
        sms_code_server = redis_conn.get('sms_%s' % mobile)
        # 3. 判断短信验证码是否过期/不存在
        if not sms_code_server:
            return JsonResponse({'code': 1, 'errmsg': '短信验证码已过期或未发送'})
        # 4. 对比用户提交的验证码和Redis中的验证码（注意转字符串，因为Redis存的是bytes）
        if sms_code != sms_code_server.decode():
            return JsonResponse({'code': 1, 'errmsg': '短信验证码错误'})
        
        # 5. 验证通过后删除短信验证码，防止重复使用
        redis_conn.delete('sms_%s' % mobile)
        # ========== 新增结束 ==========
        
        # 判断是否勾选用户协议
        if allow != True:
            return JsonResponse({'code':1,'errmsg':'请同意用户协议'})
        # 3. 注册用户
        try:
            user = User.objects.create_user(username=username,mobile=mobile,password=password)
            # request.session['user_id'] = user.id
        except Exception as e:
            return JsonResponse({'code':400,'errmsg':'注册失败'})
        from django.contrib.auth import login
        #request,user
        #状态保持 --登录用户的状态保持
        login(request,user)
        # 4. 返回响应
        response = JsonResponse({'code':0,'errmsg':'OK'})
        # 设置cookie username,有效期15天（与登录保持一致）
        response.set_cookie('username', username, max_age=3600*24*15)
        return response


'''
登录

前端：
当用户把用户名和密码输入完成之后，会点击登录按钮。这个时候前端应该发送一个axios请求

后端：
请求    ： 接收数据，验证数据
业务逻辑： 验证用户名和密码是否正确，session
响应    ： 返回JSON数据 0 成功。 400 失败

步骤：
1. 接收数据
2. 验证数据
3. 验证用户名和密码是否正确
4. session
5. 判断是否记住登录
6. 返回响应
'''
class LoginView(View):
    """用户登录"""
    def post(self,request):
        """
        实现登录逻辑
        :param request: 请求对象
        :return: 登录结果
        """
        # 1.接收参数
        # 1.1 从请求体中提取JSON字符串
        # 1.2 从JSON字符串中提取参数
        # 2. 校验参数
        # 2.1 校验是否为空
        # 2.2 校验用户名和密码是否为空
        # 3. 验证用户名和密码是否正确
        # 4. session
        # 5. 判断是否记住登录
        # 6. 返回响应
        dict = json.loads(request.body.decode())
        username = dict.get('username')
        password = dict.get('password')
        remembered = dict.get('remembered')
        # 2.1 校验是否为空
        if not all([username, password]):
            return JsonResponse({'code':400,'errmsg':'缺少必传参数'})

        # 根据登录数据修改用户认证字段
        if re.match('^1[3-9]\d{9}$',username):
            # 手机号登录
            User.USERNAME_FIELD = 'mobile'
        else:
            # 用户名登录
            User.USERNAME_FIELD = 'username'

        # 3. 验证用户名和密码是否正确
        user = authenticate(username=username,password=password)
        # 判断是否为空，为空则用户名或密码错误
        if not user:
            return JsonResponse({'code':400,'errmsg':'用户名或密码错误'})
        # 4. session
        #login作用是把登录用户的信息保存到session中
        login(request,user)
        # 5. 判断是否记住登录
        if remembered != True:
            #如果没有记住登录状态，设置session过期时间为0，即浏览器关闭时过期
            request.session.set_expiry(0)
        else:
           # 如果记住：设置session过期时间为两周
           request.session.set_expiry(60*60*24*14)

        response = JsonResponse({'code':0,'errmsg':'OK'})
        # 设置cookie username,有效期15天
        # response.set_cookie('username', user.username, max_age=3600 * 24 * 15)
        response.set_cookie('username',username,max_age=3600*24*15)

        from apps.carts.utils import merge_cookie_to_redis
        # 合并cookie中的购物车数据到Redis
        merge_cookie_to_redis(request,response)

        # 6. 返回响应
        return response
from django.contrib.auth import logout  # 用于用户退出登录
class LogoutView(View):
    """用户退出登录"""
    def delete(self,request):
        """
        实现退出登录逻辑
        :param request: 请求对象
        :return: 退出登录结果
        """
        # 1. 清除session
        logout(request)
        # 2. 退出登录，重定向到登录页
        response = JsonResponse({'code':0, 'errmsg':'OK' })
        # 3. 退出登录时清除cookie中的username
        response.delete_cookie('username')

        # 4. 返回响应
        return response

# loginRequiredMixin
# from django.contrib.auth.mixins import LoginRequiredMixin, AccessMixin

# class LoginRequiredJSONMixin(AccessMixin):
#     """验证用户是否登录的扩展类，未登录则返回JSON响应"""

#     def dispatch(self, request, *args, **kwargs):
#         if not request.user.is_authenticated:
#             return JsonResponse({'code': 400, 'errmsg': '请先登录'})
#         return super().dispatch(request, *args, **kwargs)

# class LoginRequiredView(LoginRequiredMixin):
    
#     def handle_no_permission(self):
#         return JsonResponse({'code': 400, 'errmsg': '请先登录'})
from utils.views import LoginRequiredView
class CenterView(LoginRequiredView,View):

    def get(self,request):
        """提供用户信息"""
        # 获取当前登录用户
        user = request.user
        
        # 构建用户信息数据
        info_data = {
            'username': user.username,
            'mobile': user.mobile,
            'email': user.email if hasattr(user, 'email') else '',
            'email_active': user.email_active if hasattr(user, 'email_active') else False
        }
        
        return JsonResponse({'code':0,'errmsg':'OK', 'info_data': info_data})

'''
1. 保存邮箱地址 2. 发送一封激活邮件 3. 用户激活邮件

前端：
当用户输入邮箱之后，点击保存。这个时候会发送axios请求。

后端：
请求          接收请求，获取数据
业务逻辑      保存邮箱地址 发送一封激活邮件
响应          JSON  code=0
路由          PUT

步骤
1. 接收请求
2. 获取数据
3. 保存邮箱地址
4. 发送一封激活邮件
5. 返回响应

需求（要实现什么功能）--> 思路（请求→业务逻辑→响应）--> 步骤 --> 代码实现
'''

class EmailView(LoginRequiredView,View):
    """保存邮箱"""
    def put(self,request):
        """
        实现保存邮箱逻辑
        :param request: 请求对象
        :return: 保存邮箱结果
        """
        # 1. 接收请求
        json_dict = json.loads(request.body.decode())
        # 2. 获取数据
        email = json_dict.get('email')
        # 3. 校验数据
        if not email:
            return JsonResponse({'code':400,'errmsg':'缺少必传参数'})
            # 校验邮箱格式是否正确
        if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$',email):
            return JsonResponse({'code':400,'errmsg':'邮箱格式不正确'})
        # 4. 保存邮箱地址
        user = request.user # 获取当前登录用户
        user.email = email
        user.save()
        # 5. 发送一封激活邮件
        # 激活链接：http://www.meiduo.site:8080/success_verify_email
        from django.core.mail import send_mail
        subject = "主题"
        message = ""
        from_email='美多商城<18761233821@163.com>'
        recipient_list=['oyqy_0919@126.com',email]
        # 邮件的内容如果是HTML格式，那么需要指定html_message参数
        # html_message = "点击按钮进行激活<a href = 'http://www.itcast.cn'>激活</a>"
        from apps.users.utils import generate_verify_email_url
        token = generate_verify_email_url(user.id)
        verify_url = "http://127.0.0.1:8080/success_verify_email.html?token=%s" % token
        html_message =  '<p>尊敬的用户您好！</p>' \
                   '<p>感谢您使用美多商城。</p>' \
                   '<p>您的邮箱为：%s 。请点击此链接激活您的邮箱：</p>' \
                   '<p><a href="%s">%s<a></p>' % (email, verify_url, verify_url)
        from celery_tasks.email.tasks import celery_send_email
        celery_send_email.delay(subject=subject
                                ,message=message
                                ,from_email=from_email
                                ,recipient_list=recipient_list
                                ,html_message=html_message)
        # send_mail(subject=subject,
        #           message=message,
        #           from_email=from_email,
        #           recipient_list=recipient_list,
        #           html_message=html_message)
        # 6. 返回响应
        return JsonResponse({'code':0,'errmsg':'OK'})

"""

我们设置163邮箱为SMTP服务器
相当与我们开启了让163邮箱帮我们发送邮件，同时设置了一些信息（特别是授权码）
"""
# 我163的授权码：FCn4v3BGScppALvL
# 我126的授权码：QUnX5unXDxTK3m8Q


class EmailVerifyView(View):
    """邮箱验证"""
    def put(self,request):
        # 1. 获取参数request.GET
        params = request.GET
        # 2. 校验参数
        token = params.get('token')
        if not token:
            return JsonResponse({'code':400,'errmsg':'缺少必传参数'})
        from apps.users.utils import check_verify_token
        user_id = check_verify_token(token)
        if not user_id:
            return JsonResponse({'code':400,'errmsg':'链接已失效'})
        user = User.objects.get(id=user_id)
        user.email_active = True
        user.save()

from apps.users.models import Address
class AddressCreateView(LoginRequiredView,View):
    """用户地址"""
    def post(self, request):
        """保存用户地址"""
        try:
            data = json.loads(request.body.decode())
        except json.JSONDecodeError:
            return JsonResponse({'code':400,'errmsg':'请求数据格式错误'})
        
        # 校验参数
        receiver = data.get('receiver')
        province_id = data.get('province_id')
        city_id = data.get('city_id')
        district_id = data.get('district_id')
        place = data.get('place')
        mobile = data.get('mobile')
        tel = data.get('tel')
        email = data.get('email')

        # 调试信息
        print(f"收到地址创建请求，数据：receiver={receiver}, province_id={province_id}, city_id={city_id}, district_id={district_id}, place={place}, mobile={mobile}")
        
        # 校验参数是否齐全
        if not all([receiver, province_id, city_id, district_id, place, mobile]):
            return JsonResponse({'code':400,'errmsg':'缺少必传参数'})
        # 校验手机号格式
        if not re.match('^1[3-9]\d{9}$',mobile):
            return JsonResponse({'code':400,'errmsg':'参数mobile有误'})
        # 校验固定电话格式（只有当tel字段有值时才验证）
        if tel and not re.match('^(0[0-9]{2,3}-)?([2-9][0-9]{6,7})+(-[0-9]{1,4})?$',tel):
            return JsonResponse({'code':400,'errmsg':'参数tel有误'})
        # 校验邮箱格式
        if email:
            if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
                return  JsonResponse({'code':400,'errmsg':'参数email有误'})
        
        user = request.user # 获取当前登录用户
        # 保存地址信息
        # 创建地址
        address = Address.objects.create(
            user=user,
            title=receiver,
            receiver=receiver,
            province_id=province_id,
            city_id=city_id,
            district_id=district_id,
            place=place,
            mobile=mobile,
            tel=tel,
            email=email
        )
        if not request.user.default_address:
            # 如果当前用户没有默认收货地址，则将当前地址设置为默认地址
            request.user.default_address = address
            request.user.save()
        
        # 新增地址成功，将新增的地址响应给前端实现局部刷新
        address_dict = {
            "id": address.id,
            "title": address.title,
            "receiver": address.receiver,
            "province": address.province.name,
            "city": address.city.name,
            "district": address.district.name,
            "place": address.place,
            "mobile": address.mobile,
            "tel": address.tel,
            "email": address.email
        }
        # 返回响应
        return JsonResponse({'code':0,'errmsg':'新增地址成功','address':address_dict})

class AddressView(LoginRequiredView, View):
    """用户地址列表"""
    def get(self, request):
        user = request.user
        # 1. 获取用户的有效地址（查询集，变量名用 addresses，避免后续覆盖）
        addresses = Address.objects.filter(user=user, is_deleted=False)
        
        address_list = []  # 存普通地址（非默认）
        default_addr_dict = None  # 单独存默认地址的字典（循环中找到后暂存）
        default_id = None  # 存默认地址ID（处理无默认地址的情况）

        # 2. 循环遍历地址：区分“默认地址”和“普通地址”
        for addr in addresses:  # 循环变量用 addr，避免和外层变量冲突
            addr_dict = {
                'id': addr.id,
                'title': addr.title,
                'receiver': addr.receiver,
                'province': addr.province.name,
                'city': addr.city.name,
                'district': addr.district.name,
                'place': addr.place,
                'mobile': addr.mobile,
                'tel': addr.tel,
            }

            # 3. 判断当前地址是否是默认地址
            if user.default_address and addr.id == user.default_address.id:
                # 是默认地址：暂存起来，不直接加入列表
                default_addr_dict = addr_dict
                default_id = addr.id
            else:
                # 不是默认地址：直接加入普通地址列表
                address_list.append(addr_dict)

        # 4. 把默认地址插入到列表最前面（循环结束后统一处理，避免重复）
        if default_addr_dict:
            address_list.insert(0, default_addr_dict)

        # 5. 处理“无默认地址”的情况：默认ID设为0（前端可识别0表示无默认）
        if not default_id:
            default_id = 0

        # 6. 返回响应
        return JsonResponse({
            'code': 0,
            'errmsg': 'ok',
            'addresses': address_list,
            'default_address_id': default_id
        })
    
class UpdateDestroyAddressView(LoginRequiredView,View):
    """修改和删除地址"""
    def put(self, request, address_id):
        """修改地址"""
        data = json.loads(request.body.decode())
        # 获取修改后的数据
        receiver = data.get('receiver')
        province_id = data.get('province_id')
        city_id = data.get('city_id')
        district_id = data.get('district_id')
        place = data.get('place')
        mobile = data.get('mobile')
        tel = data.get('tel')
        email = data.get('email')
        # 校验数据
        if not all([receiver, province_id, city_id, district_id, place, mobile]):
            return JsonResponse({'code':400,'errmsg':'缺少必传参数'})
        # 校验手机号格式
        if not re.match('^1[3-9]\d{9}$',mobile):
            return JsonResponse({'code':400,'errmsg':'参数mobile有误'})
        # 校验固定电话格式（只有当tel字段有值时才验证）
        if tel:
            if not re.match(r'^(0[0-9]{2,3}-)?([2-9][0-9]{6,7})+(-[0-9]{1,4})?$', tel):
                return JsonResponse({'code': 400, 
                                          'errmsg': '参数tel有误'})
        if email:
            if not re.match(r'^[a-z0-9][\w\.\-]*@[a-z0-9\-]+(\.[a-z]{2,5}){1,2}$', email):
                return JsonResponse({'code': 400, 
                                          'errmsg': '参数email有误'})
        try:
            Address.objects.filter(id=address_id).update(
                user=request.user,
                title=receiver,
                receiver=receiver,
                province_id=province_id,
                city_id=city_id,
                district_id=district_id,
                place=place,
                mobile=mobile,
                tel=tel,
                email=email
            )
        except Exception as e:
            logger.error(e)
            return JsonResponse({'code':400,'errmsg':'修改地址失败'})
        address = Address.objects.get(id=address_id)
        address_dict = {
            "id": address.id,
            "title": address.title,
            "receiver": address.receiver,
            "province": address.province.name,
            "city": address.city.name,
            "district": address.district.name,
            "place": address.place,
            "mobile": address.mobile,
            "tel": address.tel,
            "email": address.email
        }

        # 响应更新地址结果
        return JsonResponse({'code': 0, 'errmsg': '更新地址成功', 'address': address_dict})
    def delete(self, request, address_id):
        """删除地址"""
        try:
            # 查询要删除的地址
            address = Address.objects.get(id=address_id)

            # 将地址逻辑删除设置为True
            address.is_deleted = True
            address.save()
        except Exception as e:
            logger.error(e)
            return JsonResponse({'code': 400, 'errmsg': '删除地址失败'})

        # 响应删除地址结果
        return JsonResponse({'code': 0, 'errmsg': '删除地址成功'})
    
class DefaultAddressView(LoginRequiredView, View):
    """设置默认地址"""

    def put(self, request, address_id):
        """设置默认地址"""
        try:
            # 接收参数,查询地址
            address = Address.objects.get(id=address_id)

            # 设置地址为默认地址
            request.user.default_address = address
            request.user.save()
        except Exception as e:
            logger.error(e)
            return JsonResponse({'code': 400, 'errmsg': '设置默认地址失败'})

        # 响应设置默认地址结果
        return JsonResponse({'code': 0, 'errmsg': '设置默认地址成功'})

class UpdateTitleAddressView(LoginRequiredView, View):
    """设置地址标题"""

    def put(self, request, address_id):
        """设置地址标题"""
        # 接收参数：地址标题
        json_dict = json.loads(request.body.decode())
        title = json_dict.get('title')

        try:
            # 查询地址
            address = Address.objects.get(id=address_id)

            # 设置新的地址标题
            address.title = title
            address.save()
        except Exception as e:
            logger.error(e)
            return JsonResponse({'code': 400, 'errmsg': '设置地址标题失败'})

        # 4.响应删除地址结果
        return JsonResponse({'code': 0, 'errmsg': '设置地址标题成功'})

# 修改密码
class ChangePasswordView(LoginRequiredView, View):
    """修改密码"""

    def put(self, request):
            """实现修改密码逻辑"""
            # 接收参数：旧密码、新密码、确认新密码
            dict = json.loads(request.body.decode())
            old_password = dict.get('old_password')
            new_password = dict.get('new_password')
            new_password2 = dict.get('new_password2')

            # 校验参数
            if not all([old_password, new_password, new_password2]):
                return JsonResponse({'code':400,
                                        'errmsg':'缺少必传参数'})


            result = request.user.check_password(old_password)
            if not result:
                return JsonResponse({'code':400,
                                        'errmsg':'原始密码不正确'})

            if not re.match(r'^[0-9A-Za-z]{8,20}$', new_password):
                return JsonResponse({'code':400,
                                        'errmsg':'密码最少8位,最长20位'})

            if new_password != new_password2:
                return JsonResponse({'code':400,
                                        'errmsg':'两次输入密码不一致'})

            # 修改密码
            try:
                request.user.set_password(new_password)
                request.user.save()
            except Exception as e:

                return JsonResponse({'code':400,
                                        'errmsg':'修改密码失败'})

            # 清理状态保持信息
            logout(request)

            response = JsonResponse({'code':0,
                                        'errmsg':'ok'})

            response.delete_cookie('username')

            # # 响应密码修改结果：重定向到登录界面
            return response

#################################################

"""
一 根据页面效果，分析需求（细心+经验）
    1. 最近浏览记录 只有登录用户才可以访问。 我们只记录登录用户的浏览记录
    2. 浏览记录应该有顺序
    3. 没有分页
二  功能
① 在用户访问商品详情的时候， 添加浏览记录
② 在个人中心，展示浏览记录

三 分析
问题1： 保存哪些数据？ 用户id，商品id,顺序（访问时间）
问题2： 保存在哪里？   一般要保存在数据库 （缺点： ① 慢 ② 频繁操作数据库） 授课
                    最好保存在redis中
           
都可以。看公司具体的安排。 服务器内存比较大。 mysql + redis  


user_id,sku_id,顺序

key: value

redis:
    string:   x  
    hash:     x 
    list:     v  
    set:      x  
    zset:     v 
            权重：值
"""

"""
添加浏览记录
    前端：
            当登录用户，访问某一个具体SKU页面的时候，发送一个axios请求。 请求携带 sku_id
    后端：
         请求：        接收请求，获取请求参数，验证参数
         业务逻辑；    连接redis，先去重，在保存到redsi中，只保存5条记录
         响应：        返回JSON

        路由：     POST        browse_histories 
        步骤：
            1. 接收请求
            2. 获取请求参数
            3. 验证参数
            4. 连接redis    list
            5. 去重
            6. 保存到redsi中
            7. 只保存5条记录
            8. 返回JSON
展示浏览记录
     前端：
           用户在访问浏览记录的时候，发送axios请求。 请求会携带session信息
    后端：
         请求：         
         业务逻辑；    连接redis,获取redis数据（[1,2,3]）.根据商品id进行数据查询，将对象转换为字典
         响应：        JSON

        路由：    GET  
        步骤：
            1. 连接redis
            2. 获取redis数据（[1,2,3]）
            3. 根据商品id进行数据查询
            4. 将对象转换为字典
            5. 返回JSON
"""
from apps.goods.models import SKU
from django_redis import get_redis_connection
class UserHistoryView(LoginRequiredView,View):

    def post(self,request):
        user=request.user

        # 1. 接收请求
        data=json.loads(request.body.decode())
        # 2. 获取请求参数
        sku_id=data.get('sku_id')
        # 3. 验证参数
        try:
            sku=SKU.objects.get(id=sku_id)
        except SKU.DoesNotExist:
            return JsonResponse({'code':400,'errmsg':'没有此商品'})
        # 4. 连接redis    list
        redis_cli=get_redis_connection('history')
        # 5. 去重(先删除 这个商品id 数据，再添加就可以了)
        # lrem：参数1：key  参数2：删除的次数（0：删除所有） 参数3：value
        redis_cli.lrem('history_%s'%user.id,0,sku_id)
        # 6. 保存到redsi中
        # lpush：参数1：key 参数2：value
        redis_cli.lpush('history_%s'%user.id,sku_id)
        # 7. 只保存5条记录
        # ltrim: 参数1：key 参数2：开始索引 参数3：结束索引（包含）
        redis_cli.ltrim("history_%s"%user.id,0,4)
        # 8. 返回JSON
        return JsonResponse({'code':0,'errmsg':'ok'})


    def get(self,request):
        # 1. 连接redis
        redis_cli=get_redis_connection('history')
        # 2. 获取redis数据（[1,2,3]）
        ids=redis_cli.lrange('history_%s'%request.user.id,0,4)
        # [1,2,3]
        # 3. 根据商品id进行数据查询
        history_list=[]
        for sku_id in ids:
            sku=SKU.objects.get(id=sku_id)
            # 4. 将对象转换为字典
            # 处理图片URL
            image_url = ''
            if sku.default_image:
                image_url = sku.default_image.url
                # 如果URL包含127.0.0.1，替换为正确的FastDFS URL
                if '127.0.0.1:8000' in image_url:
                    from django.conf import settings
                    # 提取FastDFS文件路径部分
                    path = image_url.split('group1')[-1]
                    if not path.startswith('/'):
                        path = '/' + path
                    # 构建正确的URL
                    image_url = settings.FDFS_BASE_URL.rstrip('/') + '/group1' + path
            
            history_list.append({
                'id':sku.id,
                'name':sku.name,
                'default_image_url': image_url,
                'price': sku.price
            })

        # 5. 返回JSON
        return JsonResponse({'code':0,'errmsg':'ok','skus':history_list})
    
    